﻿using Microsoft.Xna.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace pacman
{
    class Deplacements
    {

        public Deplacements()
        {

        }

        public void afficherTab2D(int[,] tab)
        {
            for (int i = 0; i < Levels.VX; i++)
            {
                for (int j = 0; j < Levels.VY; j++)
                {
                    if (tab[i, j] < 10) Console.Write(" ");
                    Console.Write(tab[i, j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        int deplacerCase(int y)
        {
            if (y==0||y>=7) return 0;
            /*La case est occupée si il s'agit d'un mur,
             ou d'une case qui empêche le retour du personnage*/
            if (y == 2) return 2;
            return 1;
        }

        bool testRetourColonne(int y, int [] tab)
        {
            if ((tab[y-1]>=7&&tab[y-2]>=7)||(tab[y+1]>=7&&tab[y+2]>=7)) return false;
            /*Vérifie si les cases qui entoure la case cible sont des cases empêchant le retour de l'IA*/
            return true;
        }

        bool testRetourLigne(int x, int [] tab)
        {
            if ((tab[x-1]>=7&&tab[x-2]>=7)||(tab[x+1]>=7&&tab[x+2]>=7)) return false;
            /*Vérifie si les cases qui entoure la case cible sont des cases empêchant le retour de l'IA*/
            return true;
        }

        int [] getColonne(int col, int [,] tab)
        {
            int i;
            int[] tamp = new int[Levels.VX];
            for(i=0;i<Levels.VX; i++)
            {
                tamp[i] = tab[i,col];
            }
            return tamp;
        }

        int [] getLigne(int lig, int [,] tab)
        {
            int[] tamp = new int[Levels.VY];
            int i;
            for(i=0;i<Levels.VY; i++)
            {
                tamp[i] = tab[lig,i];
            }
            return tamp;
        }

        int chercher2 (int [,]tab,int x, int y,int i)
        {
            if (tab[x,y-1]==3) return 1; /* 2 à gauche*/
            else if (tab[x-1,y]==3) return 2; /*2 en haut*/
            else if (tab[x+1,y]==3) return 3;/*2 en bas*/
            else if (tab[x,y+1]==3) return 4;/*2 à droite*/
            else
            {
                switch (i)
                {
                    case 1: /*Perso venant de la droite*/
                        if (tab[x,y-1]==2) return 1;
                        else if (tab[x-1,y]==2) return 2;
                        else if(tab[x+1,y]==2) return 3;
                        break;
                    case 2: /*Perso venant du bas*/
                         if (tab[x-1,y]==2) return 2;
                         else if (tab[x,y+1]==2) return 4;
                         else if (tab[x,y-1]==2) return 1;
                         break;
                    case 3:/*Perso venant du haut*/
                        if (tab[x+1,y]==2) return 3;
                        else if (tab[x,y+1]==2) return 4;
                        else if (tab[x,y-1]==2) return 1;
                        break;
                    case 4:/*Perso venant de la gauche*/
                        if (tab[x,y+1]==2) return 4;
                            else if (tab[x-1,y]==2) return 2;
                            else if (tab[x+1,y]==2) return 3;
                        break;
                    default:
                        if (tab[x,y-1]==2) return 1;
                        else if (tab[x-1,y]==2) return 2;
                        else if(tab[x+1,y]==2) return 3;
                        else if (tab[x,y+1]==2) return 4;
                        break;
                }
            }
            return 0;
        }

        void tunnel (int x, int y, int [,] tab, int i)
        {
            switch (i)
            {
                case 0:/*Déplacement en bas*/
                    if (deplacerCase(tab[x,y-1]) != 0 && tab[x, y - 1] != 3 && tab[x, y - 1] != 2) tab[x, y - 1] = 7;
                    else if (tab [x,y-1]==7) tab[x,y-1]=9;

                    if (deplacerCase(tab[x,y+1]) != 0 && tab[x, y + 1] != 3 && tab[x, y + 1] != 2) tab[x, y + 1] = 7;
                    else if (tab[x,y+1]==7) tab[x,y+1]=9;

                    if (deplacerCase(tab[x-1, y]) != 0 && tab[x - 1, y] != 3 && tab[x-1, y] != 2) tab[x - 1, y] = 7;
                    else if (tab[x-1,y]==7) tab[x-1,y]=9;

                    /*Bloque les cases à droite, à gauche et en haut du perso si elles sont accèssibles pour empêcher un retour en arrière*/
                    break;
                case 1:/*Déplacement à droite*/
                    if (deplacerCase(tab[x, y-1]) != 0 && tab[x, y - 1] != 3 && tab[x, y - 1] != 2) tab[x, y - 1] = 7;
                    else if (tab [x,y-1]==7) tab[x,y-1]=9;

                    if (deplacerCase(tab[x-1, y]) != 0 && tab[x - 1, y] != 3 && tab[x-1, y] != 2) tab[x - 1, y] = 7;
                    else if (tab[x-1,y]==7) tab[x-1,y]=9;

                    if (deplacerCase(tab[x+1, y]) != 0 && tab[x + 1, y] != 3 && tab[x+1, y] != 2) tab[x + 1, y] = 7;
                    else if (tab[x+1,y]==7) tab[x+1,y]=9;

                    /*Bloque les cases à gauche, en haut et en bas du perso si elles sont accèssibles pour empêcher un retour en arrière*/
                    break;
                case 2:/*Déplacement en haut*/
                    if (deplacerCase(tab[x, y-1]) != 0 && tab[x, y - 1] != 3 && tab[x, y - 1] != 2) tab[x, y - 1] = 7;
                    else if (tab [x,y-1]==7) tab[x,y-1]=9;

                    if (deplacerCase(tab[x, y+1]) != 0 && tab[x, y + 1] != 3 && tab[x, y + 1] != 2) tab[x, y + 1] = 7;
                    else if (tab[x,y+1]==7) tab[x,y+1]=9;

                    if (deplacerCase(tab[x+1, y]) != 0 && tab[x + 1, y] != 3 && tab[x+1, y] != 2) tab[x + 1, y] = 7;
                    else if (tab[x+1,y]==7) tab[x+1,y]=9;

                    /*Bloque les cases à droite, à gauche et en bas du perso si elles sont accèssibles pour empêcher un retour en arrière*/
                    break;
                case 3:/*Déplacement à gauche*/
                    if (deplacerCase(tab[x, y+1]) != 0 && tab[x, y + 1] != 3 && tab[x, y - 1] != 2) tab[x, y + 1] = 7;
                    else if (tab[x,y+1]==7) tab[x,y+1]=9;

                    if (deplacerCase(tab[x-1, y]) != 0 && tab[x - 1, y] != 3 && tab[x, y - 1] != 2) tab[x - 1, y] = 7;
                    else if (tab[x-1,y]==7) tab[x-1,y]=9;

                    if (deplacerCase(tab[x+1, y]) != 0 && tab[x + 1, y] != 3 && tab[x, y - 1] != 2) tab[x + 1, y] = 7;
                    else if (tab[x+1,y]==7) tab[x+1,y]=9;

                    /*Bloque les cases à droite, en haut et en bas du perso si elles sont accèssibles pour empêcher un retour en arrière*/
                    break;
                default: break;
            }
        }

        void reinitTunnel (int x, int y, int [,] tab)
        {
            if (tab[x-1,y]==7)tab[x-1,y]=1;
            else if (tab[x-1,y]==9)tab[x-1,y]=7;

            if (tab[x+1,y]==7)tab[x+1,y]=1;
            else if (tab[x+1,y]==9)tab[x+1,y]=7;

            if (tab[x,y-1]==7)tab[x,y-1]=1;
            else if (tab[x,y-1]==9)tab[x,y-1]=7;

            if (tab[x,y+1]==7)tab[x,y+1]=1;
            else if (tab[x,y+1]==9)tab[x,y+1]=7;
        }

        int searchNext(int[,] tab, int x, int y, int i, int n, int m)
        {
            switch (i)
            {
                case 1: /*Perso venant de la droite*/
                    if (tab[x, y - 1] == n+m) return 1;
                    else if (tab[x - 1, y] == n+m) return 2;
                    else if (tab[x + 1, y] == n+m) return 3;
                    break;
                case 2: /*Perso venant du bas*/
                    if (tab[x - 1, y] == n+m) return 2;
                    else if (tab[x, y + 1] == n+m) return 4;
                    else if (tab[x, y - 1] == n+m) return 1;
                    break;
                case 3:/*Perso venant du haut*/
                    if (tab[x + 1, y] == n+m) return 3;
                    else if (tab[x, y + 1] == n+m) return 4;
                    else if (tab[x, y - 1] == n+m) return 1;
                    break;
                case 4:/*Perso venant de la gauche*/
                    if (tab[x, y + 1] == n+m) return 4;
                    else if (tab[x - 1, y] == n+m) return 2;
                    else if (tab[x + 1, y] == n+m) return 3;
                    break;
                default:
                    if (tab[x, y - 1] == n+m) return 1;
                    else if (tab[x - 1, y] == n+m) return 2;
                    else if (tab[x + 1, y] == n+m) return 3;
                    else if (tab[x, y + 1] == n + m) return 4;
                    break;
            }
            return 0;
        }

        void updateChemin(int x, int y,int[,] chemin, int n)
        {
            int m=chemin[x, y];
            chemin[x, y] = n;
            int i = searchNext(chemin, x, y, 0,m , 1);
            while (i!=0)
            {
                switch (i)
                {
                    case 1:
                        chemin[x, y - 1] = n;
                        y -= 1;
                        break;
                    case 2:
                        chemin[x - 1, y] = n;
                        x -= 1;
                        break;
                    case 3:
                        chemin[x + 1, y] = n;
                        x += 1;
                        break;
                    case 4:
                        chemin[x, y + 1] = n;
                        y += 1;
                        break;
                }
                i = searchNext(chemin, x, y, i, m++, 1);
                n++;
            }
        }

        void deleteChemin(int x, int y, int[,] tab)
        {
            int i = 5;
            while (i != 0)
            {
                i = searchNext(tab, x, y, i, tab[x, y], 1);
                tab[x, y] = 0;
                switch (i)
                {
                    case 1:
                        y -= 1;
                        break;
                    case 2:
                        x -= 1;
                        break;
                    case 3:
                        x += 1;
                        break;
                    case 4:
                        y += 1;
                        break;
                }
            }
        }

        bool distance(int x, int y, int z, int t, int n)
        {
            return (Math.Abs(x-z) + Math.Abs(y-t)==n);
        }

        bool deplacementIA (int x, int y, int z, int t, int [,] tab,int [,] chemin)
        {
            bool test = false;
            int i=1,j=1;
            if (y>t) j=-1;
            else if (y==t) j=0;
            if (x>z)i=-1;
            else if (x==z) i=0;
            tab[x,y]=8;

            /*Les 4 lignes suivantes permettent de visualiser les effets de la fonction au pas à pas.*/
            afficherTab2D(tab);
            Console.ReadKey(true);
            //afficherTab2D(chemin);
            //Console.ReadKey(true);
            /*Appuyez sur entrée pour faire progresser la fonction*/

            if((j==0)&&(i==0)) /*Vous êtes arrivé à destination*/
            {
                tab[x,y]=2;
                return true;
            }
            else if ((j != 0) && (deplacerCase(tab[x, y+j]) != 0) && testRetourColonne(x,getColonne(y+j,tab))) /*test de déplacement à droite/gauche de l'IA en fonction de j*/
            {
                if (deplacerCase(tab[x, y+j]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                {
                    if (chemin[x, y] < chemin[x, y+j] - 1)
                    {
                        updateChemin(x , y+j, chemin, chemin[x, y]+1);
                        return true;
                    }
                    else
                    {
                        chemin[x, y] = 0;
                        tab[x, y] = 0;
                        return false;
                    }
                }
                tunnel (x,y,tab,(j+4)%4);
                chemin[x, y + j] = chemin[x, y]+1;
                if (deplacementIA(x, y + j, z, t, tab, chemin))
                {
                    test = true;
                    tab[x, y] = 2;
                    if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                }
                reinitTunnel(x,y,tab);

                if (deplacerCase(tab[x+i,y])!=0) /*test de déplacement en bas/haut de l'IA en fonction de i*/
                {
                    if (deplacerCase(tab[x+i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x+i, y] - 1)
                        {
                            updateChemin(x+i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(i+3)%4);
                    chemin[x+i, y] = chemin[x, y]+1;

                    if (deplacementIA(x + i, y, z, t, tab, chemin))
                    {
                        if (test == true) deleteChemin(x,y+j,chemin);
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if (deplacerCase(tab[x-i, y]) != 0 && testRetourLigne(y, getLigne(x - i, tab))) /*test de déplacement en haut/bas de l'IA en fonction de i*/
                {
                    if (deplacerCase(tab[x-i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x - i, y] - 1)
                        {
                            updateChemin(x-i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(-i+3)%4);
                    chemin[x - i, y] = chemin[x, y]+1;
                    if (deplacementIA(x-i,y,z,t,tab,chemin))
                    {
                        if (test == true)
                        {
                            if (chemin[x, y + j] != 0) deleteChemin(x, y + j, chemin);
                            else deleteChemin(x + i, y, chemin);
                        }
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }
                
                if ((deplacerCase(tab[x, y-j]) != 0) && testRetourColonne(x, getColonne(y-j,tab))) /*test de déplacement à gauche/droite de l'IA en fonction de j*/
                {
                    if (deplacerCase(tab[x, y-j]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x, y-j] - 1)
                        {
                            updateChemin(x, y - j, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(-j+4)%4);
                    chemin[x, y-j] = chemin[x, y]+1;
                    if (deplacementIA(x, y - j, z, t, tab, chemin))
                    {
                        if (test == true)
                        {
                            if (chemin[x, y + j] != 0) deleteChemin(x, y + j, chemin);
                            else if (chemin[x+i, y] != 0) deleteChemin(x + i, y, chemin);
                            else deleteChemin(x - i, y, chemin);
                        }
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }
                if (!test)
                {
                    chemin[x, y] = 0;
                    tab[x,y]=0;
                    return false;
                }
                else return true;
            }
            else if (j==0) /*L'IA est aligné avec la colonne de la destination*/
            {
                test = false;
                if (deplacerCase(tab[x+i, y]) != 0) /*test de déplacement en bas/haut de l'IA en fonction de i*/
                {
                    if (deplacerCase(tab[x+i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x+i, y] - 1)
                        {
                            updateChemin(x+i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(i+3)%4);
                    chemin[x+i, y] = chemin[x, y]+1;
                    if (deplacementIA(x + i, y, z, t, tab, chemin))
                    {
                        test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if (deplacerCase(tab[x, y+1]) != 0) /*test de déplacement à droite de l'IA*/
                {
                    if (deplacerCase(tab[x, y+1]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x, y+1] - 1)
                        {
                            updateChemin(x, y + 1, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,1);
                    chemin[x, y + 1] = chemin[x, y]+1;
                    if (deplacementIA(x, y + 1, z, t, tab, chemin))
                    {
                        if (test == true) deleteChemin(x + i, y, chemin);
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if (deplacerCase(tab[x-i, y]) != 0 && testRetourLigne(y, getLigne(x - i, tab))) /*test de déplacement en haut/bas de l'IA en fonction de i*/
                {
                    if (deplacerCase(tab[x-i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x-i, y] - 1)
                        {
                            updateChemin(x-i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(-i+3)%4);
                    chemin[x-i, y] = chemin[x, y]+1;
                    if (deplacementIA(x - i, y, z, t, tab,chemin))
                    {
                        if (test == true)
                        {
                            if (chemin[x, y + 1] != 0) deleteChemin(x, y + 1, chemin);
                            else deleteChemin(x + i, y, chemin);
                        }
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if ((deplacerCase(tab[x, y-1]) != 0) && testRetourColonne(x, getColonne(y-1,tab))) /*test de déplacement à gauche de l'IA*/
                {
                    if (deplacerCase(tab[x, y-1]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x, y-1] - 1)
                        {
                            updateChemin(x, y -1, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,3);
                    chemin[x, y - 1] = chemin[x, y]+1;
                    if (deplacementIA(x, y - 1, z, t, tab,chemin))
                    {
                        if (test == true)
                        {
                            if (chemin[x, y + 1] != 0) deleteChemin(x, y + j, chemin);
                            else if (chemin[x + i, y] != 0) deleteChemin(x + i, y, chemin);
                            else deleteChemin(x - i, y, chemin);
                        }
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }
                if (!test)
                {
                    chemin[x, y] = 0;
                    tab[x, y] = 0;
                    return false;
                }
                else return true;
            }
            else /*L'IA est alignée par rapport à l'axe des X ou le déplacement vers la case suivante est impossible*/
            {
                test = false;
                if (i==0) i=1;
                if (deplacerCase(tab[x+i, y]) != 0 && testRetourLigne(y, getLigne(x + i, tab))) /*test de déplacement à droite de l'IA*/
                {
                    if (deplacerCase(tab[x+i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x+i, y] - 1)
                        {
                            updateChemin(x+i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(i+3)%4);
                    chemin[x+i, y] = chemin[x, y]+1;
                    if (deplacementIA(x + i, y, z, t, tab,chemin))
                    {
                        test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if ((deplacerCase(tab[x-i,y]) != 0) && testRetourLigne(y, getLigne(x-i, tab))) /*test de déplacement à gauche de l'IA*/
                {
                    if (deplacerCase(tab[x-i, y]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x - i, y] - 1)
                        {
                            updateChemin(x-i, y, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(-i+3)%4);
                    chemin[x-i, y] = chemin[x, y]+1;
                    if (deplacementIA(x - i, y, z, t, tab,chemin))
                    {
                        if (test == true) deleteChemin(x+i, y, chemin);
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }

                if (deplacerCase(tab[x, y-j]) != 0 && testRetourColonne(x, getColonne(y-j,tab))) /*test de déplacement en haut/bas de l'IA en fonction de i*/
                {
                    if (deplacerCase(tab[x, y-j]) == 2)/*L'IA a déjà trouvé un chemin passant par ce point*/
                    {
                        if (chemin[x, y] < chemin[x , y-j] - 1)
                        {
                            updateChemin(x, y - j, chemin, chemin[x, y]+1);
                            return true;
                        }
                        else
                        {
                            chemin[x, y] = 0;
                            tab[x, y] = 0;
                            return false;
                        }
                    }
                    tunnel (x,y,tab,(-j+4)%4);
                    chemin[x, y - j] = chemin[x, y]+1;
                    if (deplacementIA(x, y - j, z, t, tab,chemin))
                    {
                        if (test == true)
                        {
                            if (chemin[x + i, y] != 0) deleteChemin(x + i, y, chemin);
                            else deleteChemin(x - i, y, chemin);
                        }
                        else test = true;
                        tab[x, y] = 2;
                        if (distance(x, y, z, t, chemin[z, t] - chemin[x, y])) return true;
                    }
                    reinitTunnel(x,y,tab);
                }
                if (!test)
                {
                    chemin[x, y] = 0;
                    tab[x, y]=0;
                    return false;
                }
                else return true;
            }
        }

        public int chemin(Vector2 depart, Vector2 destination, int[,] tab)
        {
            int y = (int)depart.X, x = (int)depart.Y;
            int t = (int)destination.X, z = (int)destination.Y;

            int[,] tab2 = new int[Levels.VX, Levels.VY];
            int[,] chemin = new int[Levels.VX, Levels.VY];
            int n, i=0;
            int j = 0;

            for (int k = 0; k < Levels.VX; k++)
            {
                for (int l=0; l<Levels.VY; l++)
                {
                    chemin[k, l] = 0;
                }
            }

            tab[x, y] = 3;
            tab[z, t] = 3;
            /*Positionne l'arrivée et le départ*/

            tab2=tab;
            deplacementIA(x, y, z, t, tab2,chemin);
            n = chemin [z,t];
            /*Affiche la distance parcourue*/
            /*Console.writeLine(i);*/
            afficherTab2D(chemin);
            Console.ReadKey(true);
            while (i< n) /*rajoute le chemin découvert sur le terrain de départ*/
            {
                j = searchNext(chemin, x, y, j,i,1);
                switch (j)
                {
                    case (1): tab[x, y - 1] = 2;
                        y--;
                        break;
                    case (2): tab[x - 1, y] = 2;
                        x--;
                        break;
                    case (3): tab[x + 1, y] = 2;
                        x++;
                        break;
                    case (4): tab[x, y + 1] = 2;
                        y++;
                        break;
                    default: break;
                }
                i++;
            }
            //afficherTab2D(tab);
            //Console.ReadKey(true);
            return n;
        }

        public Vector3 seRapprocher(int[,] tab, Vector2 position, int nb)
        {
            int i = nb, y = (int)position.X, x = (int)position.Y;
            int j = 0;
            tab[x, y] = 1;

            while (i > 0)
            {
                tab[x, y] = 1;
                j = chercher2(tab, x, y, j);

                switch (j)
                {
                    case 1:
                        y--;
                        break;
                    case 2:
                        x--;
                        break;
                    case 3:
                        x++;
                        break;
                    case 4:
                        y++;
                        break;
                    default:
                        tab[x, y] = 4;
                        return new Vector3((float)y, (float)x,0f);
                }
                i--;
            }
            tab[x, y] = 4;
            return new Vector3((float)y, (float)x, (float)chercher2(tab, x, y, j));
        }

        /**
        * \brief Preconditions : 0<=a<TAILLE_max, 0<=b<TAILLE_max
        * <br /> Postconditions : Eloigne un perso de sa destination de nb case(s) et retourne les coordonnées d'arrivée ainsi que l'orientation du perso.
        */
        public Vector3 sEloigner(int[,] tab, Vector2 position, int nb)
        {
            int i = nb, y = (int)position.X, x = (int)position.Y;
            int j = 0;


            while (i > 0)
            {
                switch (chercher2(tab, x, y, j))
                {
                    case 1:
                        if (deplacerCase(tab[x, y+1]) != 0)
                        {
                            j = 4;
                            tab[x, y] = 2;
                            y++;
                        }
                        else
                        {
                            tab[x, y] = 4;
                            return new Vector3((float)y, (float)x, 0f); ;
                        }
                        break;
                    case 2:
                        if (deplacerCase(tab[x+1,y]) != 0)
                        {
                            j = 3;
                            tab[x, y] = 2;
                            x++;
                        }
                        else
                        {
                            tab[x, y] = 4;
                            return new Vector3((float)y, (float)x, 0f);
                        }
                        break;
                    case 3:
                        if (deplacerCase(tab[x-1,y]) != 0)
                        {
                            j = 2;
                            tab[x, y] = 2;
                            x--;
                        }
                        else
                        {
                            tab[x, y] = 4;
                            return new Vector3((float)y, (float)x, 0f);
                        }
                        break;
                    case 4:
                        if (deplacerCase(tab[x, y-1]) != 0)
                        {
                            j = 1;
                            tab[x, y] = 2;
                            y--;
                        }
                        else
                        {
                            tab[x, y] = 4;
                            return new Vector3((float)y, (float)x, 0f);
                        }
                        break;
                    default:
                        tab[x, y] = 4;
                        return new Vector3((float)y, (float)x, 0f);
                }
                tab[x, y] = 2;
                i--;
            }
            return new Vector3((float)y, (float)x, (float) j);
        }
    }
}
